Method and system for handling storage in response to migration of a virtual machine in a virtualization environment

ABSTRACT

A method for handling storage in response to migration of a virtual machine in a virtualization environment, including receiving an I/O request for a virtual disk, determining that a service virtual machine which implements a storage controller is not registered as owner of the virtual disk, obtaining ownership of the virtual disk by the service virtual machine, the service virtual machine handling the I/O request after obtaining ownership of the virtual disk.

CROSS REFERENCE TO RELATED APPLICATIONS

The present application is a continuation application of U.S. patentapplication Ser. No. 13/207,345, filed on Aug. 10, 2011, which is herebyincorporated by reference in its entirety.

The present application is related to application Ser. No. 13/207,357,filed on Aug. 10, 2011, now issued as U.S. Pat. No. 8,850,130, entitled“METADATA FOR MANAGING I/O AND STORAGE FOR A VIRTUALIZATIONENVIRONMENT”, application Ser. No. 13/207,365, filed on Aug. 10, 2011,now issued as U.S. Pat. No. 8,549,518, entitled “METHOD AND SYSTEM FORIMPLEMENTING A MAINTENANCE SERVICE FOR MANAGING I/O AND STORAGE FOR AVIRTUALIZATION ENVIRONMENT”, application Ser. No. 13/207,371, filed Aug.10, 2011, now issued as U.S. Pat. No. 9,009,106, entitled “METHOD ANDSYSTEM FOR IMPLEMENTING WRITABLE SNAPSHOTS IN A VIRTUALIZED STORAGEENVIRONMENT”, and application Ser. No. 13/207,375, filed Aug. 10, 2011,entitled “METHOD AND SYSTEM FOR IMPLEMENTING FAST DATA CONVOLUTION USINGSLIDING WINDOWS”, and which are all hereby incorporated by reference intheir entirety.

The present application is related to application Ser. No. 13/744,649,now issued as U.S. Pat. No. 9,389,887, entitled “METHOD AND SYSTEM FORMANAGING DE-DUPLICATION OF DATA IN A VIRTUALIZATION ENVIRONMENT”,application Ser. No. 13/744,655, entitled “SYSTEM AND METHOD FORIMPLEMENTING STORAGE FOR A VIRTUALIZATION ENVIRONMENT”, application Ser.No. 13/744,668, now issued as U.S. Pat. No. 9,256,475, entitled “METHODAND SYSTEM FOR HANDLING OWNERSHIP TRANSFER IN A VIRTUALIZATIONENVIRONMENT”, application Ser. No. 13/744,683, now issued as U.S. Pat.No. 9,052,936, entitled “METHOD AND SYSTEM FOR COMMUNICATING TO ASTORAGE CONTROLLER IN A VIRTUALIZATION ENVIRONMENT”, and applicationSer. No. 13/744,703, now issued as U.S. Pat. No. 8,997,097, entitled“SYSTEM FOR IMPLEMENTING A VIRTUAL DISK IN A VIRTUALIZATION ENVIRONMENT”all filed on even date herewith, and which are all hereby incorporatedby reference in their entirety.

FIELD

This disclosure concerns an architecture for managing I/O and storagedevices in a virtualization environment.

BACKGROUND

A “virtual machine” or a “VM” refers to a specific software-basedimplementation of a machine in a virtualization environment, in whichthe hardware resources of a real computer (e.g., CPU, memory, etc.) arevirtualized or transformed into the underlying support for the fullyfunctional virtual machine that can run its own operating system andapplications on the underlying physical resources just like a realcomputer.

Virtualization works by inserting a thin layer of software directly onthe computer hardware or on a host operating system. This layer ofsoftware contains a virtual machine monitor or “hypervisor” thatallocates hardware resources dynamically and transparently. Multipleoperating systems run concurrently on a single physical computer andshare hardware resources with each other. By encapsulating an entiremachine, including CPU, memory, operating system, and network devices, avirtual machine is completely compatible with most standard operatingsystems, applications, and device drivers. Most modern implementationsallow several operating systems and applications to safely run at thesame time on a single computer, with each having access to the resourcesit needs when it needs them.

Virtualization allows one to run multiple virtual machines on a singlephysical machine, with each virtual machine sharing the resources ofthat one physical computer across multiple environments. Differentvirtual machines can run different operating systems and multipleapplications on the same physical computer.

One reason for the broad adoption of virtualization in modern businessand computing environments is because of the resource utilizationadvantages provided by virtual machines. Without virtualization, if aphysical machine is limited to a single dedicated operating system, thenduring periods of inactivity by the dedicated operating system thephysical machine is not utilized to perform useful work. This iswasteful and inefficient if there are users on other physical machineswhich are currently waiting for computing resources. To address thisproblem, virtualization allows multiple VMs to share the underlyingphysical resources so that during periods of inactivity by one VM, otherVMs can take advantage of the resource availability to processworkloads. This can produce great efficiencies for the utilization ofphysical devices, and can result in reduced redundancies and betterresource cost management.

Data Centers are often architected as diskless computers (“applicationservers”) that communicate with a set of networked storage appliances(“storage servers”) via a network, such as a Fiber Channel or Ethernetnetwork. A storage server exposes volumes that are mounted by theapplication servers for their storage needs. If the storage server is ablock-based server, it exposes a set of volumes that are also calledLogical Unit Numbers (LUNs). If, on the other hand, a storage server isfile-based, it exposes a set of volumes that are also called filesystems. Either way, a volume is the smallest unit of administration fora storage device, e.g., a storage administrator can set policies tobackup, snapshot, RAID-protect, or WAN-replicate a volume, but cannot dothe same operations on a region of the LUN, or on a specific file in afile system.

Storage devices comprise one type of physical resources that can bemanaged and utilized in a virtualization environment. For example,VMWare is a company that provides products to implement virtualization,in which networked storage devices are managed by the VMWarevirtualization software to provide the underlying storage infrastructurefor the VMs in the computing environment. The VMWare approach implementsa file system (VMFS) that exposes storage hardware to the VMs. TheVMWare approach uses VMDK “files” to represent virtual disks that can beaccessed by the VMs in the system. Effectively, a single volume can beaccessed and shared among multiple VMs.

While this known approach does allow multiple VMs to perform I/Oactivities upon shared networked storage, there are also numerousdrawbacks and inefficiencies with this approach. For example, becausethe VMWare approach is reliant upon the VMFS file system, administrationof the storage units occurs at a too-broad level of granularity. Whilethe virtualization administrator needs to manage VMs, the storageadministrator is forced to manage coarse-grained volumes that are sharedby multiple VMs. Configurations such as backup and snapshot frequencies,RAID properties, replication policies, performance and reliabilityguarantees etc. continue to be at a volume level, and that isproblematic. Moreover, this conventional approach does not allow forcertain storage-related optimizations to occur in the primary storagepath.

Therefore, there is a need for an improved approach to implement I/O andstorage device management in a virtualization environment.

SUMMARY

Embodiments of the present invention provide an architecture formanaging I/O operations and storage devices for a virtualizationenvironment. According to some embodiments, a Service VM is employed tocontrol and manage any type of storage device, including direct-attachedstorage in addition to network-attached and cloud-attached storage. TheService VM implements the Storage Controller logic in the user space,and with the help of other Service VMs in a cluster, virtualizes allstorage hardware as one global resource pool that is high inreliability, availability, and performance. IP-based requests are usedto send I/O request to the Service VMs. The Service VM can directlyimplement storage and I/O optimizations within the direct data accesspath, without the need for add-on products.

Further details of aspects, objects, and advantages of the invention aredescribed below in the detailed description, drawings, and claims. Boththe foregoing general description and the following detailed descriptionare exemplary and explanatory, and are not intended to be limiting as tothe scope of the invention.

BRIEF DESCRIPTION OF THE DRAWINGS

The drawings illustrate the design and utility of embodiments of thepresent invention, in which similar elements are referred to by commonreference numerals. In order to better appreciate the advantages andobjects of embodiments of the invention, reference should be made to theaccompanying drawings. However, the drawings depict only certainembodiments of the invention, and should not be taken as limiting thescope of the invention.

FIG. 1 illustrates an example architecture to implement I/O and storagedevice management in a virtualization environment according to someembodiments of the invention.

FIGS. 2A-C show alternate approaches to implement I/O requests accordingto some embodiments of the invention.

FIG. 3 illustrates the components of a Service VM according to someembodiments of the invention.

FIG. 4 illustrates the components of an I/O Director module according tosome embodiments of the invention.

FIG. 5 shows the actions of Admission Control to implement QoSfunctionality according to some embodiments of the invention.

FIG. 6 illustrates a storage hierarchy according to some embodiments ofthe invention.

FIG. 7 illustrates an approach for implementing deduplication accordingto some embodiments of the invention.

FIG. 8 illustrates metadata for implementing I/O and storage devicemanagement in a virtualization environment according to some embodimentsof the invention.

FIG. 9 illustrates shared vDisks according to some embodiments of theinvention.

FIG. 10 illustrates shared-nothing vDisks according to some embodimentsof the invention.

FIG. 11 shows a flowchart of an approach for handling movement ofvirtual machines for shared nothing vDisks according to some embodimentsof the invention.

FIGS. 12A-E illustrate the approach of FIG. 11.

FIG. 13 shows a flowchart of an approach for handling failure of aService VM for a shared vDisk according to some embodiments of theinvention.

FIG. 14 is a block diagram of a computing system suitable forimplementing an embodiment of the present invention.

DETAILED DESCRIPTION OF THE EMBODIMENTS OF THE INVENTION

Embodiments of the present invention provide an improved approach toimplement I/O and storage device management in a virtualizationenvironment. According to some embodiments, a Service VM is employed tocontrol and manage any type of storage device, including direct-attachedstorage in addition to network-attached and cloud-attached storage. TheService VM implements the Storage Controller logic in the user space,and with the help of other Service VMs in a cluster, virtualizes allstorage hardware as one global resource pool that is high inreliability, availability, and performance. IP-based requests are usedto send I/O request to the Service VMs. The Service VM can directlyimplement storage and I/O optimizations within the direct data accesspath, without the need for add-on products.

FIG. 1 illustrates an architecture for implementing storage managementin a virtualization environment according to some embodiments of theinvention. The architecture of FIG. 1 can be implemented for adistributed platform that contains multiple servers 100 a and 100 b thatmanages multiple-tiers of storage. The multiple tiers of storageincludes storage that is accessible through a network 140, such as cloudstorage 126 or networked storage 128 (e.g., a SAN or “storage areanetwork”). Unlike the prior art, the present embodiment also permitslocal storage 122/124 that is within or directly attached to the serverand/or appliance to be managed as part of the storage pool 160. Examplesof such storage include Solid State Drives (henceforth “SSDs”) 125 orHard Disk Drives (henceforth “HDDs” or “spindle drives”) 127. Thesecollected storage devices, both local and networked, form a storage pool160. Virtual disks (or “vDisks”) can be structured from the storagedevices in the storage pool 160, as described in more detail below. Asused herein, the term vDisk refers to the storage abstraction that isexposed by a Service VM to be used by a user VM. In some embodiments,the vDisk is exposed via iSCSI (“internet small computer systeminterface”) or NFS (“network file system”) and is mounted as a virtualdisk on the user VM.

Each server 100 a or 100 b runs virtualization software, such as VMwareESX(i), Microsoft Hyper-V, or RedHat KVM. The virtualization softwareincludes a hypervisor 130/132 to manage the interactions between theunderlying hardware and the one or more user VMs 102 a, 102 b, 102 c,and 102 d that run client software.

A special VM 110 a/110 b is used to manage storage and I/O activitiesaccording to some embodiment of the invention, which is referred toherein as a “Service VM”. This is the “Storage Controller” in thecurrently described architecture. Multiple such storage controllerscoordinate within a cluster to form a single-system. The Service VMs 110a/110 b are not formed as part of specific implementations ofhypervisors 130/132. Instead, the Service VMs run as virtual machinesabove hypervisors 130/132 on the various servers 102 a and 102 b, andwork together to form a distributed system 110 that manages all thestorage resources, including the locally attached storage 122/124, thenetworked storage 128, and the cloud storage 126. Since the Service VMsrun above the hypervisors 130/132, this means that the current approachcan be used and implemented within any virtual machine architecture,since the Service VMs of embodiments of the invention can be used inconjunction with any hypervisor from any virtualization vendor.

Each Service VM 110 a-b exports one or more block devices or NFS servertargets that appear as disks to the client VMs 102 a-d. These disks arevirtual, since they are implemented by the software running inside theService VMs 110 a-b. Thus, to the user VMs 102 a-d, the Service VMs 110a-b appear to be exporting a clustered storage appliance that containssome disks. All user data (including the operating system) in the clientVMs 102 a-d resides on these virtual disks.

Significant performance advantages can be gained by allowing thevirtualization system to access and utilize local (e.g.,server-internal) storage 122 as disclosed herein. This is because I/Operformance is typically much faster when performing access to localstorage 122 as compared to performing access to networked storage 128across a network 140. This faster performance for locally attachedstorage 122 can be increased even further by using certain types ofoptimized local storage devices, such as SSDs 125.

Once the virtualization system is capable of managing and accessinglocally attached storage, as is the case with the present embodiment,various optimizations can then be implemented to improve systemperformance even further. For example, the data to be stored in thevarious storage devices can be analyzed and categorized to determinewhich specific device should optimally be used to store the items ofdata. Data that needs to be accessed much faster or more frequently canbe identified for storage in the locally attached storage 122. On theother hand, data that does not require fast access or which is accessedinfrequently can be stored in the networked storage devices 128 or incloud storage 126.

Another advantage provided by this approach is that administrationactivities can be handled on a much more efficient granular level.Recall that the prior art approaches of using a legacy storage appliancein conjunction with VMFS heavily relies on what the hypervisor can do atits own layer with individual “virtual hard disk” files, effectivelymaking all storage array capabilities meaningless. This is because thestorage array manages much coarser grained volumes while the hypervisorneeds to manage finer-grained virtual disks. In contrast, the presentembodiment can be used to implement administrative tasks at much smallerlevels of granularity, one in which the smallest unit of administrationat the hypervisor matches exactly with that of the storage tier itself.

Yet another advantage of the present embodiment of the invention is thatstorage-related optimizations for access and storage of data can beimplemented directly within the primary storage path. For example, insome embodiments of the invention, the Service VM 110 a can directlyperform data deduplication tasks when storing data within the storagedevices. This is far advantageous to prior art approaches that requireadd-on vendors/products outside of the primary storage path to providededuplication functionality for a storage system. Other examples ofoptimizations that can be provided by the Service VMs include quality ofservice (QOS) functions, encryption, and compression. The newarchitecture massively parallelizes storage, by placing a storagecontroller—in the form of a Service VM—at each hypervisor, and thusmakes it possible to render enough CPU and memory resources to achievethe aforementioned optimizations.

FIG. 2A illustrates an example approach that can be taken in someembodiments of the invention to submit I/O requests to the Service VMs210 a/210 b from user VMs 202. In this approach, the user VM 202 sendsI/O requests 250 a to the Service VMs in the form of iSCSI or NFSrequests. The term “iSCSI” or “Internet Small Computer System Interface”refers to an IP-based storage networking standard for linking datastorage facilities together. By carrying SCSI commands over IP networks,iSCSI can be used to facilitate data transfers over intranets and tomanage storage over any suitable type of network or the Internet. TheiSCSI protocol allows iSCSI initiators to send SCSI commands to iSCSItargets at remote locations over a network. In another embodiment of theinvention, the user VM 202 sends I/O requests 250 b to the Service VMsin the form of NFS requests. The term “NFS” or “Network File System”interface refers to an IP-based file access standard in which NFSclients send file-based requests to NFS servers via a proxy folder(directory) called “mount point”. Going forward, this disclosure willinterchangeably use the term iSCSI and NFS to refer to the IP-basedprotocol used to communicate between the hypervisor and the Service VM.Note that while both protocols are network-based, the currentlydescribed architecture makes it possible to use them over the virtualnetwork within the hypervisor. No iSCSI or NFS packets will need toleave the machine, because the communication—the request and theresponse—begins and ends within the single hypervisor host.

Here, the user VM 202 structures its I/O requests into the iSCSI format.The iSCSI or NFS request 250 a designates the IP address for a ServiceVM from which the user VM 202 desires I/O services. The iSCSI or NFSrequest 250 a is sent from the user VM 202 to a virtual switch 252within hypervisor 252 to be routed to the correct destination. If therequest is to be intended to be handled by the Service VM 210 a withinthe same server 200 a, then the iSCSI or NFS request 250 a is internallyrouted within server 200 a to the Service VM 210 a. As described in moredetail below, the Service VM 210 a includes structures to properlyinterpret and process that request 250 a.

It is also possible that the iSCSI or NFS request 250 a will be handledby a Service VM 210 b on another server 200 b. In this situation, theiSCSI or NFS request 250 a will be sent by the virtual switch 252 to areal physical switch to be sent across network 240 to the other server200 b. The virtual switch 255 within the hypervisor 233 on the server233 will then route the request 250 a to the Service VM 210 b forfurther processing.

FIG. 2B illustrates an alternate approach in which the I/O requests fromthe user VM 202 is in the normal SCSI protocol to a storage device. Thehypervisor then converts this SCSI request into an iSCSI or an NFSrequest as part of its hardware emulation layer. In other words, thevirtual SCSI disk attached to the user VM is either an iSCSI LUN or anNFS file in an NFS server. In this approach, an iSCSI initiator 272 orthe NFS client software is employed to convert the SCSI-formattedrequests into the appropriate iSCSI- or NFS-formatted requests that canbe handled by the Service VM 210 a. The advantage of this approach overthe approach of FIG. 2A is that there is no need to individuallyreconfigure or make sure that the software for the user VMs 202 can workwith the iSCSI or NFS protocol.

According to some embodiments, the service VM runs the Linux operatingsystem. As noted above, since the service VM exports a block-device orfile-access interface to the user VMs, the interaction between the userVMs and the service VMs follows the iSCSI or NFS protocol, eitherdirectly or indirectly via the hypervisor's hardware emulation layer.

For easy management of the appliance, the Service VMs all have the sameIP address isolated by internal VLANs (virtual LANs in the virtualswitch of the hypervisor). FIG. 2C illustrates this aspect of thearchitecture. The Service VM 210 a on node 200 a implements two virtualnetwork interface cards (NICs) 261 a and 261 b. One of the virtual NICs261 a corresponds to an internal VLAN that permits the User VM 202 tocommunicate with the Service VM 210 a using the common IP address. Thevirtual switch 260 would therefore route all communications internal tothe node 200 a between the User VM 202 and the Service VM 210 a usingthe first virtual NIC 261 a, where the common IP address is managed tocorrespond to the Service VM 210 a due to its membership in theappropriate VLAN.

The second virtual NIC 261 b is used to communicate with entitiesexternal to the node 200 a, where the virtual NIC 261 b is associatedwith an IP address that would be specific to Service VM 210 a (and noother service VM). The second virtual NIC 261 b is therefore used toallow Service VM 210 a to communicate with other service VMs, such asService VM 210 b on node 200 b. It is noted that Service VM 210 b wouldlikewise utilize VLANs and multiple virtual NICs 263 a and 263 b toimplement management of the appliance.

For easy management of the appliance, the storage is divided up intoabstractions that have a hierarchical relationship to each other. FIG. 6illustrates the storage hierarchy of the storage objects according tosome embodiments of the invention, where all storage in the storageappliance collectively forms a Storage Universe. These storage devicesmay encompass any suitable devices, such as SSDs, HDDs on the variousservers (“server-internal” or local storage), SAN, and Cloud storage.

Storage with similar characteristics is classified into tiers. Thus, allSSDs can be classified into a first tier and all HDDs may be classifiedinto another tier etc. In a heterogeneous system with different kinds ofHDDs, one may classify the disks into multiple HDD tiers. This actionmay similarly be taken for SAN and cloud storage.

The storage universe is divided up into storage pools—essentially acollection of specific storage devices. An administrator may beresponsible for deciding how to divide up the storage universe intostorage pools. For example, an administrator may decide to just make onestorage pool with all the disks in the storage universe in that pool.However, the principal idea behind dividing up the storage universe isto provide mutual exclusion—fault isolation, performance isolation,administrative autonomy—when accessing the disk resources.

This may be one approach that can be taken to implement QoS techniques.For example, one rogue user may result in an excessive number of randomIO activity on a hard disk—thus if other users are doing sequential IO,they still might get hurt by the rogue user. Enforcing exclusion(isolation) through storage pools might be used to provide hardguarantees for premium users. Another reason to use a storage pool mightbe to reserve some disks for later use (field replaceable units, or“FRUs”).

As noted above, the Service VM is the primary software component withinthe server that virtualizes I/O access to hardware resources within astorage pool according to embodiments of the invention. This approachessentially provides for a separate and dedicated controller for eachand every node within a virtualized data center (a cluster of nodes thatrun some flavor of hypervisor virtualization software), since each nodewill include its own Service VM. This is in contrast to conventionalstorage architectures that provide for a limited number of storagecontrollers (e.g., four controllers) to handle the storage workload forthe entire system, and hence results in significant performancebottlenecks due to the limited number of controllers. Unlike theconventional approaches, each new node will include a Service VM toshare in the overall workload of the system to handle storage tasks.Therefore, the current approach is infinitely scalable, and provides asignificant advantage over the conventional approaches that have alimited storage processing power. Consequently, the currently describedapproach creates a massively-parallel storage architecture that scalesas and when hypervisor hosts are added to a datacenter.

FIG. 3 illustrates the internal structures of a Service VM according tosome embodiments of the invention. As previously noted, the Service VMsare not formed as part of specific implementations of hypervisors.Instead, the Service VMs run as virtual machines above hypervisors onthe various nodes. Since the Service VMs run above the hypervisors, thismeans that the current approach can be used and implemented within anyvirtual machine architecture, since the Service VMs of embodiments ofthe invention can be used in conjunction with any hypervisor from anyvirtualization vendor. Therefore, the Service VM can be configured tooperate ubiquitously anywhere within the computing environment, and willnot need to be custom-configured for each different type of operatingenvironment. This is particularly useful because the industry-standardiSCSI or NFS protocols allow the Service VM to be hypervisor-agnostic.

The main entry point into the Service VM is the central controllermodule 304 (which is referred to here as the “I/O Director module 304”).The term I/O Director module is used to connote that fact that thiscomponent directs the I/O from the world of virtual disks to the pool ofphysical storage resources. In some embodiments, the I/O Director moduleimplements the iSCSI or NFS protocol server.

A write request originating at a user VM would be sent to the iSCSI orNFS target inside the service VM's kernel. This write would beintercepted by the I/O Director module 304 running in user space. I/ODirector module 304 interprets the iSCSI LUN or the NFS file destinationand converts the request into an internal “vDisk” request (e.g., asdescribed in more detail below). Ultimately, the I/O Director module 304would write the data to the physical storage. I/O Director module 304 isdescribed in more detail below in conjunction with the description ofFIG. 4.

Each vDisk managed by a Service VM corresponds to a virtual addressspace forming the individual bytes exposed as a disk to user VMs. Thus,if the vDisk is of size 1 TB, the corresponding address space maintainedby the invention is 1 TB. This address space is broken up into equalsized units called vDisk blocks. Metadata 310 is maintained by theService VM to track and handle the vDisks and the data and storageobjects in the system that pertain to the vDisks. The Metadata 310 isused to track and maintain the contents of the vDisks and vDisk blocks.

In order to determine where to write and read data from the storagepool, the I/O Director module 304 communicates with a DistributedMetadata Service module 430 that maintains all the metadata 310. In someembodiments, the Distributed Metadata Service module 430 is a highlyavailable, fault-tolerant distributed service that runs on all theService VMs in the appliance. The metadata managed by DistributedMetadata Service module 430 is itself kept on the persistent storageattached to the appliance. According to some embodiments of theinvention, the Distributed Metadata Service module 430 may beimplemented on SSD storage.

Since requests to the Distributed Metadata Service module 430 may berandom in nature, SSDs can be used on each server node to maintain themetadata for the Distributed Metadata Service module 430. TheDistributed Metadata Service module 430 stores the metadata that helpslocate the actual content of each vDisk block. If no information isfound in Distributed Metadata Service module 430 corresponding to avDisk block, then that vDisk block is assumed to be filled with zeros.The data in each vDisk block is physically stored on disk in contiguousunits called extents. Extents may vary in size when de-duplication isbeing used. Otherwise, an extent size coincides with a vDisk block.Several extents are grouped together into a unit called an extent group.An extent group is then stored as a file on disk. The size of eachextent group is anywhere from 16 MB to 64 MB. In some embodiments, anextent group is the unit of recovery, replication, and many otherstorage functions within the system.

Further details regarding methods and mechanisms for implementingMetadata 310 are described below and in co-pending application Ser. No.13/207,357, which is hereby incorporated by reference in its entirety.

A health management module 308 (which may hereinafter be referred to asa “Curator”) is employed to address and cure any inconsistencies thatmay occur with the Metadata 310. The Curator 308 oversees the overallstate of the virtual storage system, and takes actions as necessary tomanage the health and efficient performance of that system. According tosome embodiments of the invention, the curator 308 operates on adistributed basis to manage and perform these functions, where a mastercurator on a first server node manages the workload that is performed bymultiple slave curators on other server nodes. MapReduce operations areperformed to implement the curator workload, where the master curatormay periodically coordinate scans of the metadata in the system tomanage the health of the distributed storage system. Further detailsregarding methods and mechanisms for implementing Curator 308 aredisclosed in co-pending application Ser. No. 13/207,365, which is herebyincorporated by reference in its entirety.

Some of the Service VMs also includes a Distributed ConfigurationDatabase module 306 to handle certain administrative tasks. The primarytasks performed by the Distributed Configuration Database module 306 areto maintain configuration data 312 for the Service VM and act as anotification service for all events in the distributed system. Examplesof configuration data 312 include, for example, (1) the identity andexistence of vDisks; (2) the identity of Service VMs in the system; (3)the physical nodes in the system; and (4) the physical storage devicesin the system. For example, assume that there is a desire to add a newphysical disk to the storage pool. The Distributed ConfigurationDatabase module 306 would be informed of the new physical disk, afterwhich the configuration data 312 is updated to reflect this informationso that all other entities in the system can then be made aware for thenew physical disk. In a similar way, the addition/deletion of vDisks,VMs and nodes would handled by the Distributed Configuration Databasemodule 306 to update the configuration data 312 so that other entitiesin the system can be made aware of these configuration changes.

Another task that is handled by the Distributed Configuration Databasemodule 306 is to maintain health information for entities in the system,such as the Service VMs. If a Service VM fails or otherwise becomesunavailable, then this module tracks this health information so that anymanagement tasks required of that failed Service VM can be migrated toanother Service VM.

The Distributed Configuration Database module 306 also handles electionsand consensus management within the system. Another task handled by theDistributed Configuration Database module is to implement ID creation.Unique IDs are generated by the Distributed Configuration Databasemodule as needed for any required objects in the system, e.g., forvDisks, Service VMs, extent groups, etc. In some embodiments, the IDsgenerated are 64-bit IDs, although any suitable type of IDs can begenerated as appropriate for embodiment so the invention. According tosome embodiments of the invention, the Distributed ConfigurationDatabase module 306 may be implemented on an SSD storage because of thereal-time guarantees required to monitor health events.

FIG. 4 illustrates the internal structures of the I/O Director module304 according to some embodiments of the invention. An iSCSI or NFSadapter 402 is used to convert the incoming iSCSI or NFS request 350that is in the iSCSI or NFS format (packet-based format) to informationthat can be used to identify the storage target of the request. Inparticular, the iSCSI or NFS request 350 is either converted into theLUN ID number or file handle and offset of the storage object to beaccessed, as well as the specific action that s being requested.

If the I/O request is intended to write to a vDisk, then the AdmissionControl module 404 determines whether the Service VM is the owner and/orauthorized to write to the particular vDisk identified in the I/Orequest. In some embodiments, a “shared nothing” architecture isimplemented such that only the specific Service VM that is listed as theowner of the vDisk is permitted to write to that vDisk. This ownershipinformation may be maintained by Distributed Configuration Databasemodule 306.

If the Service VM is not the owner, The Distributed ConfigurationDatabase module 306 is consulted to determine the owner. The owner isthen asked to relinquish ownership so that the current Service VM canthen perform the requested I/O operation. If the Service VM is theowner, then the requested operation can be immediately processed.

Admission Control 404 can also be used to implement I/O optimizations aswell. For example, Quality of Service (QoS) optimizations can beimplemented using the Admission Control 404. For many reasons, it isdesirable to have a storage management system that is capable ofmanaging and implementing QoS guarantees. This is because many computingand business organizations must be able to guarantee a certain level ofservice in order to effectively implement a shared computing structure,e.g., to satisfy the contractual obligations of service levelagreements.

FIG. 5 illustrates one approach for implementing QoS with AdmissionControl 404. This approach is premised upon the storage objects, such asthe vDisks, being configured to have certain parameters that correspondto desired QoS properties. Multiple requests queues can be establishedfor requests having different priority levels. For example, a highpriority queue 506 can be established to queue requests that should behandled with special dispatch. A low priority queue 508 can beestablished to hold requests that correspond to lower priority requestsor requesters.

When the I/O Request 502 is received by a request analyzer 504 inAdmission Control 404, the identify and/or type of request/requester ischecked to see if the I/O request 502 should be handled in anyparticular way to satisfy the QoS parameters. If the I/O request 502 isa high priority request, then it is added to the high priority queue506. If the I/O request 502 is a low priority request, then it is addedto the low priority queue 508.

Returning back to FIG. 4, a vDisk Controller 410 is used to perform theactual read and write operations upon the storage objects. This is thesoftware component that determines where the data sits on the vDisks,and accesses those vDisks to implement the desired I/O request.Specialized metadata is used to track the storage objects that areaccessed by the vDisk Controller 410.

Embodiments of the invention can be used to directly implementde-duplication when implementing I/O in a virtualization environment.De-duplication refers to the process of making sure that a specific dataitem is not excessively duplicated multiple times within a storagesystem. Even if there are multiple users or entities that separatelyperform operations to store the same data item, the de-duplicationprocess will operate to store only a limited number of copies of thedata item, but allow those multiple users/entities to jointly access thecopies that are actually stored within the storage system.

In some embodiments, de-duplication is performed directly on primarystorage using the virtualized storage management system. The containerabstraction can be used to specify a de-duplication domain, wherede-duplication is performed for data stored within the container. Datain different containers is not de-duplicated even if it is the same. Acontainer is assigned one storage pool—this defines the disks where thedata for that container will be stored. A container supports severalconfiguration parameters that determine how the data on that containeris treated, including for example some or all of the following:

1. Replication factor: Data in a container is replicated based on thisreplication factor. Replicas are placed on different servers wheneverpossible.

2. Reed Solomon parameters: While all data is written initially based onthe specified replication factor, it may be converted later to use ReedSolomon encoding to further save on storage capacity. The datacontraction policy on the vDisks enforces when the data is converted touse Reed Solomon encoding.3. Encryption type: Data in a container is encrypted based on thespecified encryption policy if any. It is noted that there are alsoother encoding schemes which can be utilized as well.4. Compression type: Data in a container is compressed based on thegiven compression type. However, when to compress is a policy that'sspecified on individual vDisks assigned to a container. That is,compression may be done inline, or it may be done offline.5. Max capacity: This parameter specifies the max total disk capacity tobe used in each tier in the assigned storage pools.6. Min reserved capacity (specified for each tier): This parameter canalso be specified for each tier in the assigned storage pools. Itreserves a certain amount of disk space on each tier for this container.This ensures that that disk space would be available for use for thiscontainer irrespective of the usage by other containers.7. Min total reserved capacity: This is the minimum reserved across alltiers. This value should be greater than or equal to the sum of the minreserved capacity per tier values.8. Max de-duplication extent size: The Rabin fingerprinting algorithmbreaks up a contiguous space of data into variable sized extents for thepurpose of de-duplication. This parameter determines the max size ofsuch extents.9. Stripe width: To get high disk bandwidth, it is important to stripedata over several disks. The stripe width dictates the number of extentscorresponding to a contiguous vDisk address space that'll be put in asingle extent group.10. Tier ordering: All tiers in the assigned storage pools are orderedrelative to each other. Hot data is placed in the tier highest up in theorder and migrated to other tiers later based on the ILM (InformationLifecycle Management or “data waterfalling”) policy. A different tierordering may be specified for random IO as opposed to sequential IO.Thus, one may want to migrate data to the SSD tier only for random IOand not for sequential IO.11. ILM policy: The ILM policy dictates when data is migrated from onetier to the tier next in the tier ordering. For example, this migrationmay start when a given tier is more than 90% full or when the data onthat tier is more than X days old.

vDisks are the virtual storage devices that are exported to user VMs bythe Service VMs. As previously discussed, the vDisk is a softwareabstraction that manages an address space of S bytes where S is the sizeof the block device. Each service VM might export multiple vDisks. Auser VM might access several vDisks. Typically, all the vDisks exportedby a service VM are accessed only by the user VMs running on that servernode. This means that all iSCSI or NFS requests originating from a userVM can stay local to the hypervisor host—going from the user VM to thehypervisor SCSI emulation layer to a virtual switch to the Service VM. AvDisk is assigned a unique container at creation time. The data in thevDisk is thus managed according to the configuration parameters set onthe container. Some additional configuration parameters are specified onthe vDisk itself, including some or all of the following:

1. De-duplication: This specifies whether de-duplication is to be usedfor this vDisk. However, when de-duplication is used is determined bythe data contraction policy.

2. Data contraction policy: The data contraction policy controls whende-duplication, compression, and Reed-Solomon encoding is applied (ifany of them are specified). De-duplication and compression may beapplied in-line to a primary storage path or out-of-line. Ifout-of-line, the data contraction policy specifies the time whendeduplication/compression are applied (e.g., X days). Reed-Solomonencoding should be applied offline. The data contraction policy mayspecify a different time for doing Reed-Solomon than fordeduplication/compression. Note that if both deduplication andcompression are specified, then data would be de-duplicated andcompressed at the same time before writing to disk.3. Min total reserved capacity: This is the minimum reserved capacityfor this vDisk across all the storage tiers. The sum of all minimumtotal reserved capacity parameters for the vDisks in a container shouldbe less than or equal to the minimum total reserved capacity set on thecontainer.4. vDisk block size: The vDisk address space is divided into equal sizedblocks. It should be less than or equal to the stripe width parameter onthe container. A relatively large vDisk block size (e.g., 128 KB) helpsreduce the metadata that is maintained.5. vDisk row blocks: The metadata of a vDisk are conceptually dividedinto rows. Each row is hash-partitioned onto one metadata serverresiding in some Service VM in this distributed system. This parametercontrols how many blocks of this vDisk are in one row.6. vDisk Capacity: This is the size (in bytes) of the vDisk addressspace. This effectively controls the size of disk that an external userVM sees.7. QoS parameters: Each vDisk may specify a priority and a fair share.Competing IO requests from various vDisks shall be scheduled based onthis priority and fair share.

In some embodiments of the invention, the basic unit of de-duplicationis the extent, which is a contiguous portion of storage on a givenstorage device. Multiple extents can be collected together and storedwithin an “extent group.”

The left portion of FIG. 7 illustrates two extent groups 750 a and 750b. Extent group 750 a includes de-duplication with existingde-duplication extents 702 a and 702 b. Extent group 750 b includes anon-de-duplication extent 704. As described in more detail below, newextents (such as extent 702 c) can be added to an existing extent group,e.g. the extent group 750 a, if there is sufficient space in theexisting extent group.

Assume that a user issues an I/O request to write an item of data 700 tostorage. The service VM 740 will perform a process to analyze the dataitem 700 and assign that data item 700 to an extent for storage. At 720,a determination is made whether de-duplication is desired or enabled. Ifnot, then at 728, a new non-de-duplication extent 704 is created withinan appropriate extent group 750 b to store the data item 700.

If de-duplication is enabled, then a further determination is made at722 whether the storage system already includes a copy of that dataitem. According to some embodiments, this is accomplished by performing“Rabin fingerprinting” upon the data that is being stored. Rabinfingerprinting is a known algorithm for objectively dividing data intoconsistent portions. This algorithm creates uniform and commonboundaries for data portions that are partitioned out of larger items ofdata. Further details regarding an exemplary approach that can be takento identify extents for de-duplication are described in co-pendingapplication Ser. No. 13/207,375, which is hereby incorporated byreference in its entirety. The SHA1 algorithm is applied to the dataportion created by Rabin fingerprinting to create a unique signature forthat data portion. This is a well-known hashing algorithm that takes anyset of arbitrary data and creates a 20 byte content-based signature. TheSHA1 algorithm creates a value that is used as an extent identifier(extent ID), which is further used to determine if an earlier copy ofthe data item 700 has already been stored in the storage system.

If a copy already exists, then a new copy of the data item 700 is notstored; instead, the existing copy stored in de-dup extent 702 b isused. A “ref_count” (or reference count) for that extent 702 b would beincremented to provide notice that a new entity is now relying upon thisextent 702 b to store the data item 700. However, if a copy of the dataitem 200 does not yet exist, then a new extent 702 c is created to storethe data item 700.

The sizes of the extents and extent groups for the invention can bechosen to suit any desired performance goals. In some embodiments, theextent groups are implemented as 64 Mbyte size files. Thenon-deduplicated extents are created to have a much larger size than thededuplicated extents. For example, the non-deduplicated extents may beimplemented with 1 Mbyte sizes and the deduplicated extents implementedwith 8 Kbyte sizes. The goal of this sizing strategy is to make thededuplicated extents as small as practical to facilitate duplicationswhile the non-deduplicated extents are made as large as practical tofacilitate efficient physical I/O operations and to prevent the metadata(e.g., the number of rows of metadata) from bloating.

As noted above, metadata is maintained by the set of Service VMs totrack and handle the data and storage objects in the system. Each vDiskcorresponds to a virtual address space forming the individual bytesexposed as a disk to user VMs. As illustrated in FIG. 8, embodiments ofthe invention maintain three mapping structures as the metadata 800 totrack the stored data. A first metadata structure (vDisk map 802) isused to map the vDisk address space for the stored extents. Given aspecified vDisk and offset, the vDisk map 802 can be used to identify acorresponding extent ID. A second metadata structure (extent ID map 804)is used to map extent IDs. Given a specified extent ID, the extent IDmap 804 can be used to identify a corresponding extent group. A thirdmetadata structure (extent group ID map 806) is used to map specificstorage information for extent group IDs. Given a specified extent groupID, the extent group ID map 306 can be used to identify correspondinginformation, such as for example, (1) disk identifier for the extentgroup, (2) list of extent IDs in that extent group, (3) informationabout the extents such as ref counts, checksums, and offset locations.

The vDisk map expects the I/O request to identify a specific vDisk andan offset within that vDisk. In the present embodiment, the unit ofstorage is the block, whereas the unit of deduplication is the extent.Therefore, the vDisk map is basically assuming the unit of storagespecified by the offset information is to a block, and then identifyingthe corresponding extent ID from that block, where the extent offset canbe derived for within the block.

The discretization into vDisk blocks helps store this information in atable in the vDisk map. Thus, given any random offset within the vDisk,one can discretize it using mod-arithmetic to obtain the correspondingvDisk block boundary. A lookup can be performed in the vDisk map forthat (vDisk, vDisk block) combination. The information in each vDiskblock is stored as a separate column in the table. A collection of vDiskblocks might be chosen to be stored in a single row—this guaranteesatomic updates to that portion of the table. A table can be maintainedfor the address space of each vDisk. Each row of this table contains themetadata for a number of vDisk blocks. Each column corresponds to onevDisk block. The contents of the column contain a number of extent IDsand the offset at which they start in the vDisk block.

As noted above, a collection of extents is put together into an extentgroup, which is stored as a file on the physical disks. Within theextent group, the data of each of the extents is placed contiguouslyalong with the data's checksums (e.g., for integrity checks). Eachextent group is assigned a unique ID (e.g., 8 byte ID) that is unique toa container. This id is referred to as the extent group ID.

The extent ID map essentially maps an extent to the extent group that itis contained in. The extent ID map forms a separate table within themetadata—one for each container. The name of the table contains the idof the container itself. The lookup key of this table is the canonicalrepresentation of an extent ID. In some embodiments, this is either a 16byte combination containing (vDiskID, Offset) for non-deduplicatedextents, or a 24 byte representation containing (extent size, SHA1 hash)for de-duplicated extents. The corresponding row in the table justcontains one column—this column contains the extent Group ID where thecorresponding extent is contained.

When updates are made to a vDisk address space, the existing extentthere is replaced by another (in case of de-duplication and/or forcertain types of copy on write operations for snapshots). Thus the oldextent may get orphaned (when it is no longer referred to by any othervDisk in that container). Such extents will ultimately be garbagecollected. However, one possible approach is to aggressively reclaimdisk space that frees up. Thus, a “ref_count” value can be associatedwith each extent. When this ref_count drops to 0, then it can be certainthat there are no other vDisks that refer this extent and therefore thisextent can immediately be deleted. The ref_count on a deduplicatedextent may be greater than one when multiple vDisks refer to it. Inaddition, this may also occur when the same extent is referred to bydifferent parts of the address space of the same vDisk. The ref_count onan extent is stored inside the metadata for the extent group in theextent Group ID map rather than in the extent ID map. This enables batchupdates to be made to several extents and to allow updates to a singleextent Group ID metadata entry. The ref_count on a non-deduplicatedextent may be greater than one when multiple snapshots of a vDisk referto that extent. One possible approach for implementing snapshots inconjunction with the present invention is described in co-pending U.S.Ser. No. 13/207,371, filed on even date herewith, which is incorporatedby reference in its entirety.

To reduce the number of lookups by the Distributed Metadata Servicemodule, an optimization can be made for the case of non-deduplicatedextents that have a ref_count of one and are owned solely by the vDiskin question. In such a case, the extent ID map does not have an entryfor such extents. Instead, the extent Group ID that they belong to isput in the vDisk address space map itself in the same entry whereinformation about the corresponding vDisk block is put. This way, the #of metadata lookups goes down by 1.

The extent Group ID map provides a mapping from a extent Group ID to thelocation of the replicas of that extent Group ID and also their currentstate. This map is maintained as a separate table per container, and islooked up with the extent Group ID as the key. The corresponding row inthe table contains as many columns as the number of replicas. Eachcolumn is referenced by the unique global disk ID corresponding to thedisk where that replica is placed. In some embodiments, disk IDs in theserver/appliance are assigned once when the disks are prepared. Afterthat, the disk ids are never changed. New or re-formatted disks arealways given a new disk ID. The mapping from disk IDs to the serverswhere they reside is maintained in memory and is periodically refreshed.

An extra column can also be provided for the vDisk ID that created thisextent group. This is used to enforce the property that only one vDiskever writes to an extent group. Thus, there is never a race wheremultiple vDisks are trying to update the same extent group.

In some embodiments, for each replica, the following information ismaintained:

-   -   a. The diskID where the replica resides.    -   b. A Version number.    -   c. A Latest Intent Sequence number. This is used for maintaining        metadata consistency and is explained later in the subsequent        sections.    -   d. The extent ids of each of the extents contained in the extent        group. This is either the 8 byte offset for non-deduplicated        extents, or 24 bytes (size, SHA1) for deduplicated extents. For        each extent, the offset in the extentGroupID file is also        contained here. Additionally a 4 byte reference count is also        stored for each extent. Finally, an overall checksum is stored        for each extent. This checksum is written after a write finishes        and is primarily used to verify the integrity of the extent        group data.    -   e. Information about all the tentative updates outstanding on        the replica. Each tentative update carries an Intent Sequence        number. It also carries the tentative version that the replica        will move to if the update succeeds.

If multiple replicas share the same information, then that informationwill not be duplicated across the replicas. This cuts down unnecessarymetadata bloat in the common case when all the replicas are the same.

At any time, multiple components in the appliance may be accessing andmodifying the same metadata. Moreover, multiple related pieces of themetadata might need to be modified together. While these needs can beaddressed by using a centralized lock manager and transactions, thereare significant performance reasons not to use these lock-basedapproaches. One reason is because this type of central lockingnegatively affects performance since all access to metadata would needto go through the centralized lock manager. In addition, the lockmanager itself would need to be made fault tolerant, which significantlycomplicates the design and also hurts performance. Moreover, when acomponent that holds a lock dies, recovering that lock becomesnon-trivial. One may use a timeout, but this results in unnecessarydelays and also timing related races.

Therefore, the advanced metadata described above provides an approachthat utilizes lock-free synchronization, coupled with careful sequencingof operations to maintain the consistency of the metadata. The main ideais that the order in which the metadata of FIG. 3 is accessed willdiffer between operations that do not change the metadata (e.g., readoperations) and operations that will result in a change to the metadata(e.g., write operations).

With regard to the three metadata maps 802, 804, and 806 shown in FIG.8, read operations should always proceed in a top-down directionstarting with vDisk map 802, then extent ID map 804, followed by extentgroup ID map 806. In contrast, write operations will proceed in thebottom-up direction starting with the extent group ID map 806, followedby the extent ID map 804, and then subsequently followed by the vDiskmap 802.

The reason this works is because any dangling or inconsistent referencescaused by a failure of the write operations in the bottom-up directionshould not result in any detectable inconsistencies for the readoperations that work in the top-down direction. This is because eachlayer of the metadata builds upon each other so that in the top-downdirection, an extent ID identified from the vDisk map 802 should have acorresponding entry in the next level extent ID map 804, which in turnis used to identify an extent group ID which itself should have acorresponding entry in the extent group ID map 806.

To explain, consider first the opposite situation in which anupdate/write operation to the metadata is made in same direction as theread operations (i.e., in the top-down direction). Assume that the writeoperation successively creates an extent ID entry in the vDisk map 802,but dies before it is able to complete the operation and therefore neverhas the opportunity to create an entry in the extent ID map 804 thatmaps the extent ID to an extent group ID. In this situation, asubsequent read operation may possibly read that extent ID from thevDisk map 802, but will encounter a dangling/inconsistent referencebecause that extent ID does not map to anything in the extent ID map804.

Now, consider if the update/write operation to the metadata is made inthe bottom-up direction. Assume that the write operation successivelycreates a mapping between the extent ID and an extent group ID in theextent ID map 804. Further assume that the operation dies before it isable to finish, and therefore never has the opportunity to create anentry in the vDisk map 802 for the extent ID. This situation alsocreates a dangling reference in the extent ID map 804. However, unlikethe previous scenario, a subsequent read operation will never reach thedangling reference in the extent ID map 304 because it has to firstaccess the vDisk map 802, and since the previous operation did not reachthis map, there is no reference to the new extent ID in the vDisk map802. Therefore, the subsequent read should not be able to find a path toreach the dangling reference in the extent ID map. In this way, thepresent approach inherently maintains the integrity of the metadatawithout needing to provide any central locking schemes for thatmetadata.

The vDisks can either be unshared (read and written by a single user VM)or shared (accessed by multiple user VMs or hypervisors) according toembodiments of the invention. FIG. 9 illustrates the shared vDiskscenario, in which a vDisk 923 can be accessed by multiple user VMs 902a and 902 b on different server nodes 900 a and 900 b, respectively. Inthe example of FIG. 9, the shared vDisk 923 is owned by Service VM 910 bon server node 900 b. Therefore, all I/O requests for vDisk 923 will bedirected to this Service VM 910 b using standard IP forwarding (NetworkAddress Translation) rules in the networking stack of the Service VMs.

For I/O requests 950 b from a user VM 902 b that resides on the sameserver node 900 b, the process to handle the I/O requests 950 b isstraightforward, and is conducted as described above. Essentially, theI/O request is in the form of an iSCSI or NFS request that is directedto a given IP address. The IP address for the I/O request is common forall the Service VM on the different server nodes, but VLANs allows theIP address of the iSCSI or NFS request to be private to a particular(local) subnet, and hence the I/O request 950 b will be sent to thelocal Service VM 910 b to handle the I/O request 950 b. Since localService VM 910 b recognizes that it is the owner of the vDisk 923 whichis the subject of the I/O request 950 b, the local Service VM 910 b willdirectly handle the I/O request 950 b.

Consider the situation if a user VM 902 a on a server node 900 a issuesan I/O request 950 a for the shared vDisk 923, where the shared vDisk923 is owned by a Service VM 910 b on a different server node 900 b.Here, the I/O request 950 a is sent as described above from the user VM902 a to its local Service VM 910 a. However, the Service VM 910 a willrecognize that it is not the owner of the shared vDisk 923. Instead, theService VM 910 a will recognize that Service VM 910 b is the owner ofthe shared vDisk 923. In this situation, the I/O request will beforwarded from Service VM 910 a to Service VM 910 b so that the owner(Service VM 910 b) can handle the forwarded I/O request. To the extent areply is needed, the reply would be sent to the Service VM 910 a to beforwarded to the user VM 902 a that had originated the I/O request 950a.

In some embodiments, an IP table 902 (e.g., a network address table or“NAT”) is maintained inside the Service VM 910 a. The IP table 902 ismaintained to include the address of the remote Server VMs. When thelocal Service VM 910 a recognizes that the I/O request needs to be sentto another Service VM 910 b, the IP table 902 is used to look up theaddress of the destination Service VM 910 b. This “NATing” action isperformed at the network layers of the OS stack at the Service VM 910 a,when the local Service VM 910 a decides to forward the IP packet to thedestination Service VM 910 b.

FIG. 10 shows an example of a “shared nothing” system, in which thevDisks 1023 a and 1023 b are un-shared vDisks. Therefore, each vDisk inthe shared nothing system will be accessed by at most one user VM. Here,vDisk 1023 a is un-shared and is accessed only by user VM 1002 a onserver node 1000 a. Similarly, vDisk 1023 b is un-shared and is accessedonly by user VM 1002 b on server node 1000 b.

Each un-shared vDisk is owned by the Service VM that is local to theuser VM which accesses that vDisk on the shared-nothing basis. In thecurrent example, vDisk 1023 a is owned by Service VM 1010 a since thisService VM is on the same server node 1000 a as the user VM 1002 a thataccesses this vDisk. Similarly, vDisk 1023 b is owned by Service VM 1010b since this Service VM is on the same server node 1000 b as the user VM1002 b that accesses this vDisk.

I/O requests 1050 a that originate user VM 1002 a would therefore behandled by its local Service VM 1010 a on the same server node 1000 a.Similarly, I/O requests 1050 b that originate user VM 1002 b wouldtherefore be handled by its local Service VM 1010 b on the same servernode 1000 b. This is implemented using the same approach previouslydescribed above, in which the I/O request in the form of an iSCSI or NFSrequest is directed to a given IP address, and where VLANs allows the IPaddress of the iSCSI or NFS request to be private to a particular(local) subnet where the I/O request 950 b will be sent to the localService VM to handle the I/O request. Since local Service VM recognizesthat it is the owner of the vDisk which is the subject of the I/Orequest, the local Service VM will directly handle the I/O request.

It is possible that a user VM will move or migrate from one node toanother node. Various virtualization vendors have implementedvirtualization software that allows for such movement by user VMs. Forshared vDisks, this situation does not necessarily affect theconfiguration of the storage system, since the I/O requests will berouted to the owner Service VM of the shared vDisk regardless of thelocation of the user VM. However, for unshared vDisks, movement of theuser VMs could present a problem since the I/O requests are handled bythe local Service VMs.

FIG. 11 illustrates a flowchart of an approach for address thissituation for shared nothing implementations according to someembodiments of the invention. The flow begins at 1102 when an I/Orequest for a given un-shared vDisk is received at a Service VM.

A determination is made at 1104 whether the Service VM is the owner ofthe un-shared vDisk. If the Service VM is not the owner of the vDisk,this means the user VM which issued the I/O request must have justrecently migrated to the node on which the Service VM resides. However,if the Service VM is the owner, this means that the user VM has notrecently migrated from another node to the current node, since theService VM is already registered as the owner of that un-shared vDisk,e.g., due to a previous I/O request that had already been handled by theService VM.

If the local Service VM is not the owner of the un-shared vDisk, then at1106, the Service VM will become the owner of that vDisk. This action isperformed by contacting the registered owner Service VM of the vDisk(known via The Distributed Configuration Database module), and askingthat owner to relinquish ownership of the vDisk. This new ownershipinformation can then be recorded with the central metadata manager.

Once the local Service VM has acquired ownership of the vDisk, then theI/O request can be locally handled by that Service VM at 1108. If theownership check at 1104 had determined that the Service VM was alreadythe owner, then 1106 would not need to be performed, and the flow wouldhave proceeded directly to 1108.

FIGS. 12A-E illustrate this sequence of actions. FIG. 12A shows anexample of a “shared nothing” system, in which the vDisks 1223 a is anun-shared vDisk and is accessed only by user VM 1202 on server node 1200a. Therefore, vDisk 1223 a is owned by Service VM 1210 a since thisService VM is on the same server node 1200 a as the user VM 1202 thataccesses this vDisk. I/O requests 1250 a that originate from user VM1202 would therefore be handled by its local Service VM 1223 a on thesame server node 1200 a.

FIG. 12B illustrates the situation when a user VM moves or migrates fromone node to another node. Here, the user VM 1202 has migrated fromserver node 1200 a to server node 1200 b. The Service VM that is localto server node 1200 b is Service VM 1210 b. At this point, the user VM1202 is now resident on a server node 1200 b that is associated with aService VM 1210 b that is different from the owner Service VM 1210 a forthe vDisk 1223 a.

Assume that user VM 1202 now decides to issue an I/O request for vDisk1223 a. This situation is illustrated in FIG. 12C. In particular, userVM 1202 has issued an I/O request 1250 b for vDisk 1223 a, which hasbeen sent to local Service VM 1210 b. However, this has now created apotential issue since local Service VM 1210 b is not the owner of thevDisk 1223 a.

To address this situation, an ownership change will occur for the vDisk1223 a. As illustrated in FIG. 12D, the Service VM 1210 a willrelinquish its current ownership of the vDisk 1223 a. The Service VM1210 b will establish itself as the new owner of vDisk 1223 a. As shownin FIG. 12E, the I/O requests 1250 b from user VM 1202, when sent tolocal Service VM 1210 b, will now be adequately handled since Service VM1210 b is the owner of vDisk 1223 a.

Other possible situations may arise that result in the need to transferownership of a vDisk from one Service VM to another Service VM. Forexample, consider if the Service VM that is the owner of a shared vDisk(or the server node that hosts the Service VM) undergoes a failure. Inthis situation, a new Service VM will need to take over as the owner ofthe vDisk to handle ongoing I/O request for that vDisk.

FIG. 13 shows a flowchart of an approach for handling ownershiptransfers according to some embodiments of the invention. At 1302,identification is made of a situation in which an ownership transfer isrequired. For example, there may be recognition that the Service VMowner of a shared vDisk has failed. This action may be accomplished, forexample, by having the Distributed Configuration Database moduleimplement regular heartbeat checks to the different Service VMs, wherean inconsistent or problematic heartbeat would be recognized as afailure of the Service VM. If the failed Service VM having the heartbeatproblem is registered as the owner of a shared vDisk, then TheDistributed Configuration Database module would recognize that a newowner is needed for the shared vDisk.

At 1304, a candidate owner is identified for the vDisk. In someembodiments, this action can be handled using a leadership electionprocess to identify the owner of the vDisk. This election process worksby having the different Service VMs “volunteer” to the owner of a vDisk,where one Service VM is actually selected as the owner while the othervolunteers are placed on a list as back-up owners. If the actual ownerfails, then the next volunteer from the list of backup owners isselected as the new owner. If that selected new owner is not available,then subsequent next candidate(s) are selected from the list until asuitable candidate is identified, e.g., a Service VM that is alive isavailable to suitably serve as the owner of the vDisk.

At 1306, the candidate owner will obtain ownership of the vDisk. In someembodiments, this action is performed modifying the metadata in thestorage system to publish the fact that the candidate Service VM is nowthe new owner of the vDisk. Thereafter, at 1308, the new owner ServiceVM will handle subsequent I/O request for that vDisk.

Therefore, what has been described is an improved architecture forimplementing I/O and storage device management in a virtualizationenvironment. According to some embodiments, a Service VM is employed tocontrol and manage any type of storage device, including directlyattached storage in addition to networked and cloud storage. The ServiceVM has an entire Storage Controller implemented in the user space, andcan be migrated as needed from one node to another. IP-based requestsare used to send I/O request to the Service VMs. The Service VM candirectly implement storage and I/O optimizations within the direct dataaccess path, without the need for add-on products.

System Architecture

FIG. 14 is a block diagram of an illustrative computing system 1400suitable for implementing an embodiment of the present invention.Computer system 1400 includes a bus 1406 or other communicationmechanism for communicating information, which interconnects subsystemsand devices, such as processor 1407, system memory 1408 (e.g., RAM),static storage device 1409 (e.g., ROM), disk drive 1410 (e.g., magneticor optical), communication interface 1414 (e.g., modem or Ethernetcard), display 1411 (e.g., CRT or LCD), input device 1412 (e.g.,keyboard), and cursor control.

According to one embodiment of the invention, computer system 1400performs specific operations by processor 1407 executing one or moresequences of one or more instructions contained in system memory 1408.Such instructions may be read into system memory 1408 from anothercomputer readable/usable medium, such as static storage device 1409 ordisk drive 1410. In alternative embodiments, hard-wired circuitry may beused in place of or in combination with software instructions toimplement the invention. Thus, embodiments of the invention are notlimited to any specific combination of hardware circuitry and/orsoftware. In one embodiment, the term “logic” shall mean any combinationof software or hardware that is used to implement all or part of theinvention.

The term “computer readable medium” or “computer usable medium” as usedherein refers to any medium that participates in providing instructionsto processor 1407 for execution. Such a medium may take many forms,including but not limited to, non-volatile media and volatile media.Non-volatile media includes, for example, optical or magnetic disks,such as disk drive 1410. Volatile media includes dynamic memory, such assystem memory 1408.

Common forms of computer readable media includes, for example, floppydisk, flexible disk, hard disk, magnetic tape, any other magneticmedium, CD-ROM, any other optical medium, punch cards, paper tape, anyother physical medium with patterns of holes, RAM, PROM, EPROM,FLASH-EPROM, any other memory chip or cartridge, or any other mediumfrom which a computer can read.

In an embodiment of the invention, execution of the sequences ofinstructions to practice the invention is performed by a single computersystem 1400. According to other embodiments of the invention, two ormore computer systems 1400 coupled by communication link 1415 (e.g.,LAN, PTSN, or wireless network) may perform the sequence of instructionsrequired to practice the invention in coordination with one another.

Computer system 1400 may transmit and receive messages, data, andinstructions, including program, i.e., application code, throughcommunication link 1415 and communication interface 1414. Receivedprogram code may be executed by processor 1407 as it is received, and/orstored in disk drive 1410, or other non-volatile storage for laterexecution.

In the foregoing specification, the invention has been described withreference to specific embodiments thereof. It will, however, be evidentthat various modifications and changes may be made thereto withoutdeparting from the broader spirit and scope of the invention. Forexample, the above-described process flows are described with referenceto a particular ordering of process actions. However, the ordering ofmany of the described process actions may be changed without affectingthe scope or operation of the invention. The specification and drawingsare, accordingly, to be regarded in an illustrative rather thanrestrictive sense.

What is claimed is:
 1. A method for handling storage in response tomigration of a virtual machine in a virtualization environment,comprising: receiving an I/O request for an unshared virtual disk ownedby a first service virtual machine, wherein a second service virtualmachine receives the I/O request; determining that the second servicevirtual machine which implements a storage controller is not registeredas owner of the unshared virtual disk, wherein only a service virtualmachine registered as owner of the unshared virtual disk is permitted toaccess the unshared virtual disk to implement the I/O request, andwherein the act of determining occurs in response to the second servicevirtual machine receiving the I/O request for the unshared virtual diskowned by the first service virtual machine; transferring ownership ofthe unshared virtual disk from the first service virtual machine to thesecond service virtual machine; and the second service virtual machineimplementing the I/O request after obtaining ownership of the unsharedvirtual disk.
 2. The method of claim 1, in which the unshared virtualdisk is accessed by at most one user virtual machine.
 3. The method ofclaim 1, in which the unshared virtual disk is implemented in ashared-nothing architecture.
 4. The method of claim 1, in whichownership of the unshared virtual disk is transferred by contacting thefirst service virtual machine to request that ownership be relinquished.5. The method of claim 4, in which a distributed configuration databasemodule is employed to contact the first service virtual machine.
 6. Themethod of claim 1, in which the second service virtual machine is notregistered as owner of the unshared virtual disk due to a recentmigration of an associated user virtual machine from a first node to asecond node.
 7. The method of claim 6, in which the second servicevirtual machine is on the second node.
 8. A computer program productembodied on a non-transitory computer readable medium, thenon-transitory computer readable medium having stored thereon a sequenceof instructions which, when executed by a processor causes the processorto execute a method for handling storage in response to migration of avirtual machine in a virtualization environment, the method comprising:receiving an I/O request for an unshared virtual disk owned by a firstservice virtual machine, wherein a second service virtual machinereceives the I/O request; determining that the second service virtualmachine which implements a storage controller is not registered as ownerof the unshared virtual disk, wherein only a service virtual machineregistered as owner of the unshared virtual disk is permitted to accessthe unshared virtual disk to implement the I/O request, and wherein theact of determining occurs in response to the second service virtualmachine receiving the I/O request for the unshared virtual disk owned bythe first service virtual machine; transferring ownership of theunshared virtual disk from the first service virtual machine to thesecond service virtual machine; and implementing the I/O request by thesecond service virtual machine after obtaining ownership of the unsharedvirtual disk.
 9. The computer program product of claim 8, in which theunshared virtual disk is accessed by at most one user virtual machine.10. The computer program product of claim 8, in which the unsharedvirtual disk is implemented in a shared-nothing architecture.
 11. Thecomputer program product of claim 8, in which ownership of the unsharedvirtual disk is transferred by contacting the first service virtualmachine to request that ownership be relinquished.
 12. The computerprogram product of claim 11, in which a distributed configurationdatabase module is employed to contact the first service virtualmachine.
 13. The computer program product of claim 8, in which thesecond service virtual machine is not registered as owner of theunshared virtual disk due to a recent migration of an associated uservirtual machine from a first node to a second node.
 14. The computerprogram product of claim 13, in which the second service virtual machineis on the second node.
 15. A computer-based system for handling storagein response to migration of a virtual machine in a virtualizationenvironment, comprising: a computer processor to execute a set ofprogram code instructions; a memory to hold the set of program codeinstructions, in which the set of program code instructions comprisesprogram code for receiving an I/O request for an unshared virtual diskowned by a first service virtual machine, wherein a second servicevirtual machine receives the I/O request; determining that the secondservice virtual machine which implements a storage controller is notregistered as owner of the virtual disk, wherein only a service virtualmachine registered as owner of the unshared virtual disk is permitted toaccess the unshared virtual disk to implement the I/O request, andwherein the act of determining occurs in response to the second servicevirtual machine receiving the I/O request for the unshared virtual diskowned by the first service virtual machine; transferring ownership ofthe unshared virtual disk from the first service virtual machine to thesecond service virtual machine; and implementing the I/O request by thesecond service virtual machine after obtaining ownership of the unsharedvirtual disk.
 16. The system of claim 15, in which the unshared virtualdisk is accessed by at most one user virtual machine.
 17. The system ofclaim 15, in which the unshared virtual disk is implemented in ashared-nothing architecture.
 18. The system of claim 15, in whichownership of the unshared virtual disk is transferred by contacting thefirst service virtual machine to request that ownership be relinquished.19. The system of claim 18, in which a distributed configurationdatabase module is employed to contact the first service virtualmachine.
 20. The system of claim 15, in which the second service virtualmachine is not registered as owner of the unshared virtual disk due to arecent migration of an associated user virtual machine from a first nodeto a second node.
 21. The system of claim 20, in which the secondservice virtual machine is on the second node.
 22. A method for handlingstorage in response to migration of a virtual machine in avirtualization environment, comprising: receiving an I/O request for anunshared virtual disk owned by a first service virtual machine, whereina second service virtual machine that implements a storage controllerreceives the I/O request; determining that the storage controller is notcurrently registered as owner of the unshared virtual disk, wherein onlya service virtual machine registered as owner of the unshared virtualdisk is permitted to access the unshared virtual disk to implement theI/O request, and wherein the act of determining occurs in response tothe second service virtual machine receiving the I/O request for theunshared virtual disk owned by the first service virtual machine;transferring ownership of the unshared virtual disk from the firstservice virtual machine to the second service virtual machine; and thestorage controller implementing the I/O request after obtainingownership of the unshared virtual disk.
 23. The method of claim 22, inwhich the unshared virtual disk is accessed by at most one user virtualmachine.
 24. The method of claim 22, in which the unshared virtual diskis implemented in a shared-nothing architecture.
 25. The method of claim22, in which ownership of the unshared virtual disk is obtained bycontacting the first service virtual machine to request that ownershipbe relinquished.
 26. The method of claim 25, in which a distributedconfiguration database module is employed to contact the first servicevirtual machine.
 27. The method of claim 22, in which the second servicevirtual machine is not registered as owner of the unshared virtual diskdue to a recent migration of an associated user virtual machine from afirst node to a second node.
 28. The method of claim 27, in which thesecond service virtual machine is on the second node.
 29. A computerprogram product embodied on a non-transitory computer readable medium,the non-transitory computer readable medium having stored thereon asequence of instructions which, when executed by a processor causes theprocessor to execute a method for handling storage in response tomigration of a virtual machine in a virtualization environment, themethod comprising: receiving an I/O request for an unshared virtual diskowned by a first service virtual machine, wherein a second servicevirtual machine that implements a storage controller receives the I/Orequest; determining that the storage controller is not currentlyregistered as owner of the unshared virtual disk, wherein only a servicevirtual machine registered as owner of the unshared virtual disk ispermitted to access the unshared virtual disk to implement the I/Orequest, and wherein the act of determining occurs in response to thesecond service virtual machine receiving the I/O request for theunshared virtual disk owned by the first service virtual machine;transferring ownership of the unshared virtual disk from the firstservice virtual machine to the second service virtual machine; and thestorage controller implementing the I/O request after obtainingownership of the unshared virtual disk.
 30. The computer program productof claim 29, in which the unshared virtual disk is accessed by at mostone user virtual machine.
 31. The computer program product of claim 29,in which the unshared virtual disk is implemented in a shared-nothingarchitecture.
 32. The computer program product of claim 29, in whichownership of the unshared virtual disk is obtained by contacting thefirst service virtual machine to request that ownership be relinquished.33. The computer program product of claim 32, in which a distributedconfiguration database module is employed to contact the first servicevirtual machine.
 34. The computer program product of claim 29, in whichthe second service virtual machine is not registered as owner of theunshared virtual disk due to a recent migration of an associated uservirtual machine from a first node to a second node.
 35. The computerprogram product of claim 34, in which the second service virtual machineis on the second node.
 36. A computer-based system for handling storagein response to migration of a virtual machine in a virtualizationenvironment, comprising: a computer processor to execute a set ofprogram code instructions; a memory to hold the set of program codeinstructions, in which the set of program code instructions comprisesprogram code for receiving an I/O request for an unshared virtual diskowned by a first service virtual machine, wherein a second servicevirtual machine that implements a storage controller receives the I/Orequest; determining that the storage controller is not currentlyregistered as owner of the unshared virtual disk, wherein only a servicevirtual machine registered as owner of the unshared virtual disk ispermitted to access the unshared virtual disk to implement the I/Orequest, and wherein the act of determining occurs in response to thesecond service virtual machine receiving the I/O request for theunshared virtual disk owned by the first service virtual machine;transferring ownership of the unshared virtual disk from the firstservice virtual machine to the second service virtual machine; andhaving the storage controller implementing the I/O request afterobtaining ownership of the unshared virtual disk.
 37. The system ofclaim 36, in which the unshared virtual disk is accessed by at most oneuser virtual machine.
 38. The system of claim 36, in which the unsharedvirtual disk is implemented in a shared-nothing architecture.
 39. Thesystem of claim 36, in which ownership of the unshared virtual disk isobtained by contacting the first service virtual machine to request thatownership be relinquished.
 40. The system of claim 39, in which adistributed configuration database module is employed to contact thefirst service virtual machine.
 41. The system of claim 36, in which thesecond service virtual machine is not registered as owner of theunshared virtual disk due to a recent migration of an associated uservirtual machine from a first node to a second node.
 42. The system ofclaim 41, in which the second service virtual machine is on the secondnode.